package base.db.lib;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.CallableStatement;
import java.sql.ResultSet;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang.StringUtils;
import base.action.lib.HttpRequestFactory;
import base.db.lib.DBDAO.DBReader;
import base.db.lib.util.ConncenFactory;
import base.util.lib.Pager;

/**
 * 列表操作
 * 
 */

@SuppressWarnings("all")
public class DBHelper {
     /*
	 * *************************************************************************
	 * **************************** 列表操作*************************************
	 * *************************************************************************
	 * 
	 */

	/**
	 * 执行SQL语句 操作成功返回 true 否返回 false
	 * 
	 * @param sql
	 *            sql语句
	 * @param params
	 *            参数列表
	 */
	private static int baseExecute(String sql, Vector params) throws Exception {

		DBDAO dao = ConncenFactory.getDao();// new DBDAO();
		//DBDAO dao =  new DBDAO();
		
		int result = -1;
		try {
			dao.setConnection(ConncenFactory.getConnection()); // 设置数据源
			result = dao.execute(sql, params);
			
		} catch (Exception e) {
			 e.printStackTrace();
			System.out.println("数据库执行操作异常 ============== " + sql);
			throw e;
		}
		
	 return result;
	 
	}
	
	/**
	 * 根据传入sql语句,传入参数返回HashMap格式的list结果集 sql语句必须为 as格式如 select id as id, name as
	 * name from demo
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @return List HashMap格式list结果集
	 */

	private static List baseList(String sql, Vector params, int startRow,
			int endRow) throws Exception {
		List list = null;
		DBDAO dao = ConncenFactory.getDao();// new DBDAO();
		//DBDAO dao = new DBDAO();
		
		try {
			dao.setConnection(ConncenFactory.getConnection()); // 设置数据源
			list = dao.query(sql, params, startRow, endRow);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("数据库返回列表操作异常 ============== " + sql);
			list = null;
			throw e;
		}
		return list;

	}
	/** sql2005 sql 2008
	 * 根据传入sql语句,传入参数返回HashMap格式的list结果集 sql语句必须为 as格式如 select id as id, name as
	 * name from demo
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @return List HashMap格式list结果集
	 */

	private static List baseList_sql(String sql, Vector params, int startRow,
			int endRow,String oderbystr) throws Exception {
		List list = null;
		DBDAO dao = ConncenFactory.getDao();// new DBDAO();
		try {
			dao.setConnection(ConncenFactory.getConnection()); // 设置数据源
			list = dao.query_sql(sql, params, startRow, endRow,oderbystr);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("数据库返回列表操作异常 ============== " + sql);
			list = null;
			throw e;
		}
		return list;

	}

	/**
	 * 根据传入sql语句返回HashMap格式的list结果集
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @return List HashMap格式list结果集
	 */
	public static List list(String sql) {
		if (StringUtils.isEmpty(sql))
			return null;
		List list = null;
		try {
			list = baseList(sql, null, -1, -1);
		} catch (Exception e) {
			System.out.println("数据库返回列表操作(无分页，有参数)异常 ============== " + sql);
			e.printStackTrace();
		}

		return list;
	}



	/**
	 * 根据传入sql语句,传入参数返回HashMap格式的list结果集 sql语句必须为 as格式如 select id as id, name as
	 * name from demo
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @return List HashMap格式list结果集
	 */

	public static List list(String sql, Vector params) {
		if (StringUtils.isEmpty(sql)){
			return null;
		}
		if (params == null || params.size() == 0){
			return null;
		}
		List list = null;
		try {
			list = baseList(sql, params, -1, -1);
		} catch (Exception e) {
			System.out.println("数据库返回列表操作(无分页，有参数)异常 ============== " + sql);
			e.printStackTrace();
		}
		return list;
	}

	/**
	 * 根据传入sql语句，每页显示行数返回HashMap格式的list结果集 sql语句必须为 as格式如 select id as id, name
	 * as name from demo
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @param pageSize
	 *            每页显示行数
	 * @return List list结果集
	 */

	public static List list(String sql, Pager pager) {
		if (StringUtils.isEmpty(sql)){
			return null;
		}
		if (pager == null){
			return null;
		}
		if (pager.getPageSize() <= 0){
			return null;
		}
		List list = null;
		try {
			int totalRows = 0;
			List list_count = baseList(getCountSql(sql), null, -1, -1);
			if (list_count.size() > 0) {
				Map temp_map = (Map) list_count.get(0);
				totalRows = Integer.parseInt(temp_map.get("num_no").toString());
			}
			
			pager.setTotalRows(totalRows);// 统计多少行数据
			pager.setStartRow(pager.getCurrentPage() * pager.getPageSize()- pager.getPageSize());// 改变pager对象 开始行数
			
			list = baseList(sql, null, pager.getStartRow(), pager.getCurrentPage()* pager.getPageSize());

		} catch (Exception e) {
			System.out.println("数据库返回列表操作(有分页，无参数)异常 ============== " + sql);
			e.printStackTrace();
			return null;
		}
		return list;
	}

	/**
	 * 根据传入sql语句，传入参数，每页显示行数(-1 表示 每页大小由浏览器高度得出)返回HashMap格式的list结果集 sql语句必须为
	 * as格式如 select id as id, name as name from demo
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @param Pager
	 *            分页 对象
	 * @return List list结果集
	 */
	public static List list(String sql, Vector params, Pager pager) {
		if (StringUtils.isEmpty(sql)){
			return null;
		}
		if (params == null || params.size() == 0 || pager == null){
			return null;
		}
		List list = null;
		try {
			int totalRows = 0;
			List list_count = baseList(getCountSql(sql), params, -1, -1);
			if (list_count.size() > 0) {
				Map temp_map = (Map) list_count.get(0);
				totalRows = Integer.parseInt(temp_map.get("num_no").toString());
			}
			// 如果 pageSize传入为 -1 表示 每页大小由浏览器高度得出
			pager.setTotalRows(totalRows);// 统计多少行数据
			
			pager.setStartRow(pager.getCurrentPage() * pager.getPageSize()- pager.getPageSize());// 改变pager对象 开始行数
			
			list = baseList(sql, params, pager.getStartRow(), pager.getCurrentPage()* pager.getPageSize());
			
		} catch (Exception e) {
			System.out.println("数据库返回列表操作(有分页，有参数)异常 ============== " + sql);
			e.printStackTrace();
			return null;
		}
		return list;
	}
	
	/**
	 * sql2005 2008支持分页SQL
	 * 根据传入sql语句，传入参数，每页显示行数(-1 表示 每页大小由浏览器高度得出)返回HashMap格式的list结果集 sql语句必须为
	 * as格式如 select id as id, name as name from demo
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @param Pager
	 *            分页 对象
	 *@param oderbystr
	 *            
	 * @return List list结果集
	 */
	public static List list_sql(String sql, Vector params, Pager pager,String oderbystr) {
		if (StringUtils.isEmpty(sql)){
			return null;
		}
		if (params == null || params.size() == 0 || pager == null){
			return null;
		}
		List list = null;
		try {
			int totalRows = 0;
			List list_count = baseList(getCountSql(sql), params, -1, -1);
			if (list_count.size() > 0) {
				Map temp_map = (Map) list_count.get(0);
				totalRows = Integer.parseInt(temp_map.get("num_no").toString());
			}
			// 如果 pageSize传入为 -1 表示 每页大小由浏览器高度得出
			pager.setTotalRows(totalRows);// 统计多少行数据
			
			pager.setStartRow(pager.getCurrentPage() * pager.getPageSize()- pager.getPageSize());// 改变pager对象 开始行数
			
			list = baseList_sql(sql, params, pager.getStartRow(), pager.getCurrentPage()* pager.getPageSize(),oderbystr);
			
		} catch (Exception e) {
			System.out.println("数据库返回列表操作(有分页，有参数)异常 ============== " + sql);
			e.printStackTrace();
			return null;
		}
		return list;
	}


	/**
	 * 根据传入sql语句，返回一条HashMap格式记录
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @return HashMap 键值对记录
	 */

	public static HashMap obj(String sql) {
		if (StringUtils.isEmpty(sql)) {
			return null;
		}
		HashMap obj = null;
		try {
			List list = baseList(sql, null, -1, -1);
			if (list == null || list.size() == 0) {
				return null;
			}
			obj = (HashMap) list.get(0);
		} catch (Exception e) {
			System.out.println("数据库返回键值对记录操作(无参数)异常 ============== " + sql);
			e.printStackTrace();

		}
		return obj;
	}

	/**
	 * 根据传入sql语句，传入参数，返回一条HashMap格式记录
	 * 
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @return HashMap 键值对记录
	 */
	public static HashMap obj(String sql, Vector params) {
		if (StringUtils.isEmpty(sql))
			return null;
		if (params == null || params.size() == 0)
			return null;
		HashMap obj = null;
		try {
			List list = baseList(sql, params, -1, -1);
			if (list == null || list.size() == 0){
				return null;
			}
			obj = (HashMap) list.get(0);
		} catch (Exception e) {
			System.out.println("数据库返回键值对记录操作(有参数)异常 ============== " + sql);
			return null;
		}
		return obj;
	}



	/**
	 * 返回查询总数的sql语句字符串
	 * 
	 * @param sql
	 *            传入查询的sql语句
	 * @return 查询总数的sql语句字符串
	 */

	public static int getCount(String sql, Vector params) {
		if (StringUtils.isEmpty(sql)){
			return 0;
			}
		if (params == null || params.size() == 0){
			return 0;
		}
		int count = 0;
		try {	
			List list_count = baseList(getCountSql(sql), params, -1, -1);
			if (list_count.size() > 0) {
				Map temp_map = (Map) list_count.get(0);
				count = Integer.parseInt(temp_map.get("num_no").toString());
			}
		} catch (Exception e) {
			System.out.println("数据库获取总数异常 ============== " + sql);
			e.printStackTrace();
			return 0;
		}
		return count;
	}

	/***************************************************************************************
	 *
	 * **************************** 存储过程操作************************************************
	 * 
	 */
	
	
	
	/**
	 * sql2005 2008 
	 * 
	 *demo  UP_GetRecordByPage ?,?,?,?,?,?
	 *
	 *调用存储过程返回 结果集合
	 * 
	 * @param callsql
	 *            传过来的存储过程带参数  UP_GetRecordByPage ?,?,?,?,?,?
	 * @param params
	 *            传入参数
	 * @return List HashMap格式list结果集
	 */
	public static List prepareCall(String callsql,Vector params) throws Exception {
		if (StringUtils.isEmpty(callsql)){
			return null;
		}
		List list = null;
		DBDAO dao = ConncenFactory.getDao();// new DBDAO();
		//DBDAO dao = new DBDAO();
		try {
			dao.setConnection(ConncenFactory.getConnection()); // 设置数据源
			list = dao.prepareCall(callsql, params);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("数据库返回列表操作异常 ============== " + callsql);
			list = null;
			throw e;
		}
		return list;
	}
	
	
	/**
	 * sql2005 2008 
	 * 
	 *demo  call newjobs(?,?.....)
	 *采用CallableStatement执行存储过程
	 *调用存储过程返回 结果集合
	 * 
	 * @param callsql
	 *            传过来的存储过程带参数  UP_GetRecordByPage ?,?,?,?,?,?
	 * @param params
	 *            传入参数
	 * @return List HashMap格式list结果集
	 */
	public static List callList(String callsql,Vector params) throws Exception {
		
		if (StringUtils.isEmpty(callsql)){
			return null;
		}
		List list = null;
		DBDAO dao = ConncenFactory.getDao();// new DBDAO();
		//DBDAO dao = new DBDAO();
		try {
			dao.setConnection(ConncenFactory.getConnection()); // 设置数据源
			list = dao.callList(callsql, params);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("数据库返回列表操作异常 ============== " + callsql);
			list = null;
			throw e;
		}
		return list;
	}
	
	
	/**
	 * sql2005 2008 
	 *demo  call newjobs(?,?.....)
	 *采用CallableStatement执行存储过程
	 *调用存储过程返回 输出参数 结果集合
	 * 
	 * @param callsql
	 *            传过来的存储过程带参数   UP_GetRecordByPage (?,?,?,?,?,?.....)
	 * @param params
	 *            传入参数
	 * @return Vector 格式为字符集合
	 */
	public static Vector executeStoredProcedure(String callsql,Vector in_params,Vector out_params) throws Exception {
		
		if (StringUtils.isEmpty(callsql)){
			return null;
		}
		List list = null;
		Vector pro_value=null;
		DBDAO dao = ConncenFactory.getDao();// new DBDAO();
		//DBDAO dao = new DBDAO();
		try {
			dao.setConnection(ConncenFactory.getConnection()); // 设置数据源
			pro_value = dao.executeStoredProcedure(callsql, in_params,out_params);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("执行存储过程异常返回列表操作异常 ============== " + callsql);
			list = null;
			throw e;
		}
		return pro_value;
		
	}
	/***************************************************************************************
	 *
	 * **************************** 存储过程操作************************************************
	 * 
	 */
	
	
	/***************************************************************************************
	 *
	 * **************************** 增加操作*************************************************
	 * 
	 */
	/**
	 * 增加操作 操作成功返回 true 否返回 false
	 * 
	 * @param tableName
	 *            表名
	 * @param cols
	 *            字段列表
	 * @param params
	 *            字段值列表
	 */
	public static boolean add(String tableName, List cols, Vector params)
			throws Exception {
		if (tableName == null || tableName.trim().equals("")){
			return false;
		}
		if (cols == null || cols.size() == 0){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int b = -1;
		try {
			String sql = setInsertOrUpdateSql(tableName, cols, "insert");// 设置插入语句
			b = baseExecute(sql, params);
		} catch (Exception e) {
			System.out.println("数据库添加操作异常 ============== " + tableName);
			throw e;
		}
		return b > -1;
	}

	/**
	 * 增加操作 操作成功返回 true 否返回 false
	 * 
	 * @param tableName
	 *            表名
	 * @param objMap
	 *            Map 封装参数对象
	 */
	public static boolean add(String tableName, Map objMap) throws Exception {
		if (tableName == null || tableName.trim().equals("")){
			return false;
		}
		if (objMap == null || objMap.size() == 0){
			return false;
		}
		List cols = new ArrayList();
		Vector params = new Vector();
		changerMap(objMap, cols, params);// 把Map 对象改变为 列名集合和参数值集合
		if (cols == null || cols.size() == 0){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int b = -1;
		try {
			String sql = setInsertOrUpdateSql(tableName, cols, "insert");// 设置插入语句
			b = baseExecute(sql, params);
		} catch (Exception e) {
                
			System.out.println("数据库添加操作异常 ============== " + tableName);
			throw e;
		}
		return b > -1;
	}

	/**
	 * *************************************************************************
	 * **************************** 修改操作*************************************
	 */
	
	
	/**
	 * 修改操作 操作成功返回 true 否返回 false
	 * 
	 * @param tableName
	 *            表名
	 * @param cols
	 *            字段列表
	 * @param params
	 *            字段值列表
	 * @param condition_SQL
	 *            条件SQL语句 where t.id=12 and t.name='zhangsan' .....
	 */
	public static boolean update(String tableName, List cols, Vector params,
			String condition_SQL) throws Exception {
		if (tableName == null || tableName.trim().equals("")){
			return false;
		}
		if (cols == null || cols.size() == 0){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int b = -1;	
		try {	
			String sql = setInsertOrUpdateSql(tableName, cols, "update");// 设置插入语句
			b = baseExecute(sql + condition_SQL, params);

		} catch (Exception e) {
			System.out.println("数据库修改操作异常 ============== " + tableName);
			throw e;
		}
		return b > -1;
	}

	/**
	 * 修改操作 操作成功返回 true 否返回 false
	 * 
	 * @param tableName
	 *            表名
	 * @param cols
	 *            字段列表
	 * @param params
	 *            字段值列表
	 * @param condition_SQL
	 *            条件SQL语句 where t.id=? and t.name=? .....
	 * @param condition_params
	 *            条件参数值列表(可变参数) where t.id=? and t.name=? ..... 其中?中值
	 */
	public static boolean update_condition(String tableName, List cols,
			Vector params, String condition_SQL, Object... condition_params)
			throws Exception {
		if (tableName == null || tableName.trim().equals("")){
			return false;
			}
		if (cols == null || cols.size() == 0){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int b = -1;
	
		try {
			String sql = setInsertOrUpdateSql(tableName, cols, "update");// 设置插入语句
			// 设置条件SQL语句中的值
			for (Object obj : condition_params) {
				params.add(obj);
			}
			b = baseExecute(sql + condition_SQL, params);

		} catch (Exception e) {
			System.out.println("数据库修改操作异常 ============== " + tableName);
			throw e;
		}
		return b > -1;
	}

	/**
	 * 修改操作 操作成功返回 true 否返回 false
	 * 
	 * @param tableName
	 *            表名
	 * @param cols
	 *            字段列表
	 * @param params
	 *            字段值列表
	 * @param condition_SQL
	 *            条件SQL语句 where t.id=? and t.name=? .....
	 * @param condition_params
	 *            条件参数值列表(可变参数) where t.id=? and t.name=? ..... 其中?中值
	 */
	public static boolean update(String tableName, List cols, Vector params,
			String condition_SQL, Vector condition_params) throws Exception {
		if (tableName == null || tableName.trim().equals("")){
			return false;
		}
		if (cols == null || cols.size() == 0){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int b = -1;
		
		try {
			String sql = setInsertOrUpdateSql(tableName, cols, "update");// 设置插入语句
			// 设置条件SQL语句中的值
			if (condition_params != null) {
				for (int i = 0; i < condition_params.size(); i++) {
					params.add(condition_params.get(i));
				}
			}
			b = baseExecute(sql + condition_SQL, params);

		} catch (Exception e) {
			System.out.println("数据库修改操作异常 ============== " + tableName);
			throw e;
		}
		return b > -1;
	}

	/**
	 * 修改操作 操作成功返回 true 否返回 false
	 * 
	 * @param tableName
	 *            表名
	 * @param objMap
	 *            Map 封装参数对象
	 * @param condition_SQL
	 *            条件SQL语句 where t.id=? and t.name=? .....
	 * @param condition_params
	 *            条件参数值列表(可变参数) where t.id=? and t.name=? ..... 其中?中值
	 */
	public static boolean update(String tableName, Map objMap,
			String condition_SQL, Vector condition_params) throws Exception {
		if (tableName == null || tableName.trim().equals("")){
			return false;
		}
		if (objMap == null || objMap.size() == 0){
			return false;
		}
		List cols = new ArrayList();
		Vector params = new Vector();
		changerMap(objMap, cols, params);// 把Map 对象改变为 列名集合和参数值集合
		if (cols == null || cols.size() == 0){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int b = -1;
		
		try {
			// 设置条件SQL语句中的值
			if (condition_params != null) {
				for (int i = 0; i < condition_params.size(); i++) {
					params.add(condition_params.get(i));
				}
			}
	    	String sql = setInsertOrUpdateSql(tableName, cols, "update");// 设置插入语句
			b = baseExecute(sql + condition_SQL, params);
		} catch (Exception e) {
			System.out.println("数据库修改操作异常 ============== " + tableName);
			throw e;
		}
		return b > -1;
	}

	/**
	 * 修改操作 操作成功返回 true 否返回 false
	 * 
	 * @param tableName
	 *            表名
	 * @param objMap
	 *            Map 封装参数对象
	 * @param condition_SQL
	 *            条件SQL语句 where t.id=? and t.name=? .....
	 * @param condition_params
	 *            条件参数值列表(可变参数) where t.id=? and t.name=? ..... 其中?中值
	 */
	public static boolean update_condition(String tableName, Map objMap,
			String condition_SQL, Object... condition_params) throws Exception {
		if (tableName == null || tableName.trim().equals("")){
			return false;
		}
		if (objMap == null || objMap.size() == 0){
			return false;
		}
		List cols = new ArrayList();
		Vector params = new Vector();
		changerMap(objMap, cols, params);// 把Map 对象改变为 列名集合和参数值集合
		if (cols == null || cols.size() == 0){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int b = -1;
		try {
			String sql = setInsertOrUpdateSql(tableName, cols, "update");// 设置插入语句
			// 设置条件SQL语句中的值
			for (Object obj : condition_params) {
				params.add(obj);
			}

			b = baseExecute(sql + condition_SQL, params);

		} catch (Exception e) {
			System.out.println("数据库修改操作异常 ============== " + tableName);
			throw e;
		}
		return b > -1;
	}

	/**
	 * 修改操作 操作成功返回 true 否返回 false
	 * 
	 * @param tableName
	 *            表名
	 * @param objMap
	 *            Map 封装参数对象
	 * @param condition_SQL
	 *            条件SQL语句 where t.id=12 and t.name='zhangsan' .....
	 */
	public static boolean update(String tableName, Map objMap,
			String condition_SQL) throws Exception {
		if (tableName == null || tableName.trim().equals("")){
			return false;
		}
		if (objMap == null || objMap.size() == 0){
			return false;
		}
		List cols = new ArrayList();
		Vector params = new Vector();
		changerMap(objMap, cols, params);// 把Map 对象改变为 列名集合和参数值集合
		if (cols == null || cols.size() == 0){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}

		int b = -1;	
		try {
			String sql = setInsertOrUpdateSql(tableName, cols, "update");// 设置插入语句
			b = baseExecute(sql + condition_SQL, params);
		} catch (Exception e) {
			System.out.println("数据库修改操作异常 ============== " + tableName);
			throw e;
		}
		return b > -1;
	}


	/**
	 * 删除操作 操作成功返回 true 否返回 false
	 * 
	 * @param cols
	 *            字段列表
	 * @param params
	 *            字段值列表
	 */
	public static boolean delete(String sql, Vector params) throws Exception {
		if (StringUtils.isEmpty(sql)){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int reustl = -1;
		try {
			reustl = baseExecute(sql, params);
		} catch (Exception e) {
			System.out.println("数据库删除操作异常 ============== " + sql);
			throw e;
		}
		return reustl > -1;
	}

	/**
	 * 执行SQL语句 操作成功返回 true 否返回 false
	 * 
	 * @param sql
	 *            sql语句
	 * @param params
	 *            参数列表
	 */
	public static boolean execute(String sql, Vector params) throws Exception {
		if (StringUtils.isEmpty(sql)){
			return false;
		}
		if (params == null || params.size() == 0){
			return false;
		}
		int result = -1;
		result = baseExecute(sql, params);
		return result >= 0;
	}
	

	/**
	 * 操作成功返回 true 否返回 false
	 * 
	 * @param sql
	 *            sql语句
	 * @param params
	 *            参数列表
	 */
	public static boolean execute(String sql) throws Exception {
		if (StringUtils.isEmpty(sql)){
			return false;
		}
		int result = 0;
		try {
			result = baseExecute(sql, null);
		} catch (Exception e) {
			System.out.println("数据库删除操作异常 ============== " + sql);
			throw e;
		}
		return result >= 0;
	}

	
	
	
	
	/**
	 * 
	 * **************************常用辅助操作begin***************
	 * 
	 */
	
	/**
	 * 把Map 对象改变为 列名集合和参数值集合
	 * 
	 * @param objMap
	 *            Map 封装参数对象
	 * @param cols
	 *            List 列名集合
	 * @param params
	 *            Vector 参数值集合
	 */
	public static void changerMap(Map objMap, List cols, Vector params) {
		Object[] strs = objMap.keySet().toArray();
		for (Object key : strs) {
			Object value = objMap.get(key);
			cols.add(key);
			params.add(value);
		}
	}

	
	/**
	 * 返回查询总数的sql语句字符串
	 * 
	 * @param sql
	 *            传入查询的sql语句
	 * @return 查询总数的sql语句字符串
	 */
	private static String getCountSql(String sql) {
		if (StringUtils.isEmpty(sql)){
			return null;
		}
		sql = sql.toLowerCase();
		StringBuilder sb = new StringBuilder();
		sb.append("select count(1) as num_no from ( ");
		if (sql.lastIndexOf(")") < sql.lastIndexOf("order by")) {
			sql = sql.substring(0, sql.lastIndexOf("order by"));
		}
		sb.append(sql);
		sb.append(" ) z");

		return sb.toString();
	}
	
	/**
	 * 根据表名和列名封装执行SQL语句
	 * 
	 * @param tableName
	 *            表名
	 * @param cols
	 *            列名结合List <String>
	 * @param flag
	 *            标识为insert 还是 update
	 * @return String
	 */
	public static String setInsertOrUpdateSql(String tableName, List cols,
			String flag) {
		// 封装SQL语句
		StringBuffer sql = new StringBuffer("");
		// 插入SQL
		if ("insert".equals(flag)) {
			sql.append(" insert into ");
			sql.append(tableName);
			sql.append(" (");
			for (int i = 0; i < cols.size(); ++i) {
				sql.append((String) cols.get(i));
				if (i == cols.size() - 1) {
					sql.append(")");
				} else {
					sql.append(",");
				}
			}
			sql.append(" values (");
			for (int i = 0; i < cols.size(); ++i) {
				if (i == cols.size() - 1) {
					sql.append("?)");
				} else {
					sql.append("?,");
				}
			}
		} else if ("update".equals(flag)) {
			sql.append("update ");
			sql.append(tableName);
			sql.append(" set  ");
			for (int i = 0; i < cols.size(); ++i) {
				sql.append((String) cols.get(i));
				sql.append("=?");
				if (i == cols.size() - 1)
					continue;
				sql.append(", ");
			}
		}
		return sql.toString();
	}
	
	/**
	 * @param <T>
	 * @param classType
	 *            对象的类型
	 * @param map
	 * @return T 返回泛型对象
	 * @throws Exception
	 */
	public static <T> T setObjectModelForMap(Class<T> classType, Map map)
			throws Exception {
		if (map == null) {
			return null;
		}
		// 获得对象的类型
		// Class classType =arg;
		// System.out.println("********************begin******************************");
		// 通过默认构造方法去创建一个新的对象，getConstructor的视其参数决定调用哪个构造方法
		// Object objectCopy = classType.getConstructor(new Class[]
		// {}).newInstance(new Object[] {});
		// 创建一个新的对象
		T objectCopy = classType.newInstance();
		// 获得对象的所有属性
		Field[] fields = classType.getDeclaredFields();
		for (int i = 0; i < fields.length; i++) {
			// 获取数组中对应的属性
			Field field = fields[i];
			String fieldName = field.getName(); // 属性名称
			String value = null;
			try {
				Object temp_value = map.get(fieldName.toLowerCase());// 从Map对象获取属性值value
				if (temp_value == null) {
					// System.out.println("没有值的属性： "+fieldName.toLowerCase());
					continue;
				}
				value = temp_value.toString();// 获取值

			} catch (Exception e) {
				throw e;
			}

			String stringLetter = fieldName.substring(0, 1).toUpperCase();
			String setName = "set" + stringLetter + fieldName.substring(1);
			Method setMethod = classType.getMethod(setName, new Class[] { field
					.getType() });
			// System.out.println("fieldName: "+fieldName);
			// 调用源对象的 getXXX（）方法

			// 根据 字段类型 设置值
			SimpleDateFormat format = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss");
			String typeName = field.getType().getName();
			if (null != value && "" != value) {
				try {
					if (typeName.equals("java.lang.String")) {
						setMethod.invoke(objectCopy, value);

					} else if (typeName.equals("java.lang.Long")) {
						setMethod.invoke(objectCopy, Long.parseLong(value));

					} else if (typeName.equals("long")) {
						setMethod.invoke(objectCopy, Long.parseLong(value));

					} else if (typeName.equals("java.util.Date")) {
						setMethod.invoke(objectCopy, format.parse(value));

					} else if (typeName.equals("java.math.BigDecimal")) {
						setMethod.invoke(objectCopy, BigDecimal.valueOf(Long
								.parseLong(value)));

					} else if (typeName.equals("java.lang.Double")) {
						setMethod.invoke(objectCopy, java.lang.Double
								.parseDouble(value));

					} else if (typeName.equals("double")) {
						setMethod.invoke(objectCopy, java.lang.Double
								.parseDouble(value));

					} else if (typeName.equals("java.lang.Integer")) {
						setMethod.invoke(objectCopy, java.lang.Integer
								.parseInt(value));
					} else if (typeName.equals("int")) {
						setMethod.invoke(objectCopy, java.lang.Integer
								.parseInt(value));
					}

				} catch (Exception e) {
					throw e;
				}
			}
		}

		return objectCopy;
	}

	/**
	 * 
	 * **************************常用辅助操作end***************
	 * 
	 */
	
	
	
	/**
	 * 
	 * **************************泛型查询结果begin***************
	 * 
	 */
	
	/**
	 * 根据传入sql语句，传入参数，返回一条HashMap格式记录
	 * 
	 * @param classType
	 *            传过来的对象类型 例如User.class
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @return T 返回泛型对象
	 */
	public static <T> T getObj(Class<T> classType, String sql, Vector params) {
		Map map = obj(sql, params);
		T obj = null;
		if (map != null) {
			try {
				obj = setObjectModelForMap(classType, map);
				return obj;
			} catch (Exception e) {
				e.printStackTrace();
				return null;
			}
		} else {
			return null;
		}
	}

	/**
	 * 根据传入sql语句和对象类型返回HashMap格式的返回泛型集合list结果集
	 * 
	 * @param classType
	 *            传过来的对象类型 例如User.class
	 * @param sql
	 *            传过来的sql语句
	 * @return List<T>返回泛型集合list
	 */
	public static <T> List<T> getTlist(Class<T> classType, String sql) {
		List<T> list = new ArrayList<T>();
		List temp_list = list(sql);
		for (Object object : temp_list) {
			Map map = (Map) object;
			try {
				T t = setObjectModelForMap(classType, map);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
				continue;
			}
		}
		return list;
	}

	/**
	 * 根据传入sql语句和对象类型返回HashMap格式的返回泛型集合list结果集
	 * 
	 * @param classType
	 *            传过来的对象类型 例如User.class
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数 * @return List<T>返回泛型集合list
	 */

	public static <T> List<T> getTlist(Class<T> classType, String sql,
			Vector params) {
		List<T> list = new ArrayList<T>();
		List temp_list = list(sql, params);
		for (Object object : temp_list) {
			Map map = (Map) object;
			try {
				T t = setObjectModelForMap(classType, map);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
				continue;
			}
		}
		return list;
	}

	/**
	 *根据传入sql语句和对象类型返回HashMap格式的返回泛型集合list结果集
	 * 
	 * @param classType
	 *            传过来的对象类型 例如User.class
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @param Pager
	 *            分页 对象
	 * @return List<T>返回泛型集合list
	 */
	public static <T> List<T> getTlist(Class<T> classType, String sql,
			Vector params, Pager pager) {
		List<T> list = new ArrayList<T>();
		List temp_list = list(sql, params, pager);
		for (Object object : temp_list) {
			Map map = (Map) object;
			try {
				T t = setObjectModelForMap(classType, map);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
				continue;
			}
		}
		return list;
	}

	/**
	 *根据传入sql语句和对象类型返回HashMap格式的返回泛型集合list结果集
	 * 
	 * @param classType
	 *            传过来的对象类型 例如User.class
	 * @param sql
	 *            传过来的sql语句
	 * @param params
	 *            传入参数
	 * @return List<T>返回泛型集合list
	 */
	public static <T> List<T> getTlist(Class<T> classType, String sql,
			Pager pager) {
		List<T> list = new ArrayList<T>();
		List temp_list = list(sql, pager);
		for (Object object : temp_list) {
			Map map = (Map) object;
			try {
				T t = setObjectModelForMap(classType, map);
				list.add(t);
			} catch (Exception e) {
				e.printStackTrace();
				continue;
			}
		}
		return list;
	}

	/**
	 * 
	 * **************************泛型查询结果end***************
	 * 
	 */
	
	
	
}
